<?php
	/**
	  * @package	MyDebuger
	  * @name		MyDebuger
	  * @brief		Clase para manejar depuracion y errores PHP
	  * @author		Hermann D. Schimpf <hschimpf@gschimpf.com>
	  * @license	http://opensource.org/licenses/gpl-2.0.php
	  * @date		2009-12-23
	  * @version	0.9.1
  	**/

	class MyDebuger implements MyVersions {
		/* version de la clase */
		private static $version			= 0;
		/* subversion de la clase */
		private static $subversion		= 9;
		/* numero de revision de la clase */
		private static $revision		= 1;

		/* nombre de la instancia */
		private $name					= False;
		/* atributo con el ultimo error producido */
		private $lastError			= False;
		/* fichero de log para el registro de depuracion */
		private $logFile				= Null;
		/* fichero lock para el fichero log */
		private $logFileLock			= False;
		/* bandera para mostrar el tiempo en los mensajes */
		private $saltoMsg				= False;
		/* bandera para des / habilitar la salida de depuracion */
		private $debugStat			= False;
		/* bandera para des / habilitar la salida de depuracion en formato HTML */
		private $html					= False;
		/* cadena para mensajes */
		private $cadenaShow			= '';
		/* atributo de tiempo de ejecucion actual */
		private static $timeNow		= 0;
		/* atributo de tiempo de ejecucion inicial */
		private static $timeStart	= 0;
		/* bandera para des / habilitar el tiempo de espera para la depuracion */
		private $timeEnabled			= False;
		/* velocidad del tiempo para la depuracion */
		private $timeStep				= 500000;
		/* valor para el color rojo */
		private $redColor				= 'c00';
		/* valor para el color verde */
		private $greenColor			= '060';
		/* valor para el color azul */
		private $blueColor			= '00a';
		/* valor para el color amarillo */
		private $yellowColor			= 'ca0';
		/* bandera para ver si se creo la instancia llamando a parent */
		private $created				= False;

		public function __construct($enableDebug = False, $name = __CLASS__, $version = Null) {
			try {
				try {
					/* verificamos si existe la clase necesaria para el funcionamiento */
					$this->verificarClase();
					/* verificamos la version que se necesita */
					$this->verificarVersion($version);
					/* modificamos la bandera */
					$this->created = True;
					/* asignamos el manejador de errores al metodo interno */
					set_error_handler(__CLASS__ . '::errorHandler', E_ALL);
					/* almacenamos el tiempo de inicio */
					$this->saveTime();
					/* asignamos el nombre a la instancia */
					$this->name = $name;
					/* verificamos si habilitamos la depuracion */
					if ($enableDebug === True)
						/* habilitamos la depuracion */
						$this->enableHtmlDebug();
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$this->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$this->show($e->getMensaje());
			}
		}

		public function __destruct() {
			/* verificamos si el archivo fichero log existe */
			if ($this->logFile !== Null) {
				/* mostramos un mensaje */
				$this->show('Eliminando bloqueo del fichero log..', False);
				/* verificamos si existe el fichero lock */
				if (file_exists($this->logFileLock))
					/* eliminamos el fichero lock del log */
					unlink($this->logFileLock);
				else
					/* mostramos un mensaje */
					$this->show($this->red('El fichero no existe..'), False);
				/* mostramos ok al mensaje */
				$this->showOK();
				/* mostramos un mensaje */
				$this->show('Finalizando fichero log');
				/* finalizamos el fichero log agregando un espacio vacio */
				$this->saveLog('', True, False);
				/* cerramos el fichero log */
				fclose($this->logFile);
			}
			/* restauramos el manejador de errores */
			restore_error_handler();
		}

		public static function getVersion($version = Null, $debug = False) {
			try {
				try {
					/* creamos una instancia */
					$getVersion = new MyDebuger($debug);
					/* verificamos si no especifico una version para comparar */
					if ($version === Null)
						/* retornamos la version actual de la clase */
						return 'v' . self::$version . '.' . self::$subversion . '.' . self::$revision;
					/* verificamos si especifico un numero */
					if (gettype($version) !== 'integer')
						/* salimos con una excepcion */
						$getVersion->newException('La version debe ser especificada en numeros');
					/* verificamos si la version es compatible */
					if ($version > ((self::$version * 100) + (self::$subversion * 10) + (self::$revision)))
						/* retornamos false */
						return False;
					/* retornamos true */
					return True;
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$getVersion->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$getVersion->show($e->getMensaje());
			}
		}

		public final function enableDemoTime($velocity = False) {
			try {
				try {
					/* verificamos si se creo la instancia */
					$this->verificarInstancia();
					/* habilitamos la bandera de demo para el tiempo */
					$this->timeEnabled = True;
					/* verificamo si se desea mas rapido */
					if ($velocity === True)
						/* aceleramos el tiempo */
						$this->timeStep = 100000;
					elseif (gettype($velocity) == 'integer')
						/* asignamos el tiempo */
						$this->timeStep = $velocity * 1000;
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$this->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$this->show($e->getMensaje());
			}
		}

		public final function getError($emptyOnGet = False, $whitOutMsg = False) {
			try {
				try {
					/* verificamos si se creo la instancia */
					$this->verificarInstancia();
					/* verificamos si es para utilizacion interna */
					if ($whitOutMsg === True)
						/* retornamos aqui el error para no mostrar mensajes */
						return $this->lastError;
					else
						/* almacenamos el error porque puede eliminarse mediante la bandera 'vaciar' */
						$errorReturn = $this->lastError;
					/* mostramos un mensaje */
					$this->show('Enviando ultimo error..', False);
					/* verificamos si se especifico vaciar */
					if ($emptyOnGet === True)
						/* eliminamos el ultimo error */
						$this->setError();
					/* mostramos OK al mensaje */
					$this->showOK();
					/* retornamos el error */
					return $errorReturn;
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$this->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$this->show($e->getMensaje());
			}
		}

		protected final function enableLog($fileName = Null) {
			try {
				try {
					/* verificamos si se creo la instancia */
					$this->verificarInstancia();
					/* verificamos si especifico un nombre para el fichero log */
					if ($fileName === Null)
						/* salimos con una excepcion */
						$this->newException('No se especifico el nombre para el fichero log');
					/* verificamos si ya existe un fichero log abierto */
					if ($this->logFile !== Null)
						/* salimos con una excepcion */
						$this->newException('Ya existe un fichero log abierto');
					/* verificamos si existe la carpeta log */
					if (!file_exists('log')) {
						/* verificamos si podemos crear una carpeta */
						if (!is_writable('./'))
							/* salimos con una excepcion */
							$this->newException('La carpeta ' . $this->italic('log') . ' no existe y no se poseen permisos para crearla');
						/* creamos la carpeta */
						mkdir('./log');
					}
					/* habilitamos el log */
					$this->crearLogFile($fileName);
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$this->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$this->show($e->getMensaje());
			}
		}

		public static final function errorHandler($errorNro, $errorMsg, $errorFile, $errorLine) {
			/* modificamos los errores de ejecucion a excepciones */
			throw new ErrorException($errorMsg, 0, $errorNro, $errorFile, $errorLine);
		}

		protected final function getTime() {
			try {
				try {
					/* verificamos si se creo la instancia */
					$this->verificarInstancia();
					/* obtenemos el tiempo actual */
					$timeInicio = explode(' ', microtime());
					/* retornamos la suma del tiempo actual */
					return $timeInicio[1] + $timeInicio[0];
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$this->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$this->show($e->getMensaje());
			}
		}

		protected final function setError($stringError = False) {
			try {
				try {
					/* verificamos si se creo la instancia */
					$this->verificarInstancia();
					/* guardamos el error */
					$this->lastError = $stringError;
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$this->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$this->show($e->getMensaje());
			}
		}

		protected final function show($stringMsg = Null, $break = True) {
			try {
				try {
					/* verificamos si se creo la instancia */
					$this->verificarInstancia();
					/* verificamos si especifico una cadena para mostrar */
					if ($stringMsg === Null)
						/* salimos con una excepcion */
						$this->newException('No se especifico la cadena a mostrar');
					/* esperamos un tiempo aleatorio */
					$this->sleepRand();
					/* almacenamos la cadena */
					$this->cadenaShow = $stringMsg;
					/* armamos la cadena de salida y la mostramos */
					$this->armarMostrarCadena($break);
					/* almacenamos la cadena en el log */
					$this->saveLog($stringMsg, $break);
					/* modificamos la bandera */
					$this->saltoMsg = True;
					/* verificamos si es un salto */
					if ($break === True)
						/* modificamos la bandera */
						$this->saltoMsg = False;
					/* vaciamos el buffer de salida */
					$this->vaciarBuffer();
					/* esperamos un tiempo aleatorio */
					$this->sleepRand();
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$this->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$this->show($e->getMensaje());
			}
		}

		protected final function showOK($withColor = True) {
			try {
				try {
					/* verificamos si se creo la instancia */
					$this->verificarInstancia();
					/* verificamos si se paso un parametro correcto */
					if (gettype($withColor) !== 'boolean')
						/* salimos con una excepcion */
						$this->newException('El parametro debe ser booleano');
					/* mostramos la cadena OK */
					$this->show($withColor === True ? $this->green('OK') : 'OK', True);
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$this->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$this->show($e->getMensaje());
			}
		}

		protected final function italic($stringText = Null) {
			try {
				try {
					/* verificamos si se creo la instancia */
					$this->verificarInstancia();
					/* verificamos si especifico la cadena */
					if ($stringText === Null)
						/* salimos con una excepcion */
						$this->newException('No se especifico la cadena a formatear');
					/* formateamos y retornamos la cadena formateada */
					return $this->getFormat($stringText, 'font-style:italic');
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$this->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$this->show($e->getMensaje());
			}
		}

		protected final function bold($stringText = Null) {
			try {
				try {
					/* verificamos si se creo la instancia */
					$this->verificarInstancia();
					/* verificamos si especifico la cadena */
					if ($stringText === Null)
						/* salimos con una excepcion */
						$this->newException('No se especifico la cadena a formatear');
					/* formateamos y retornamos la cadena formateada */
					return $this->getFormat($stringText, 'font-weight:bold');
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$this->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$this->show($e->getMensaje());
			}
		}

		protected final function underline($stringText = Null) {
			try {
				try {
					/* verificamos si se creo la instancia */
					$this->verificarInstancia();
					/* verificamos si especifico la cadena */
					if ($stringText === Null)
						/* salimos con una excepcion */
						$this->newException('No se especifico la cadena a formatear');
					/* formateamos y retornamos la cadena formateada */
					return $this->getFormat($stringText, 'text-decoration:underline');
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$this->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$this->show($e->getMensaje());
			}
		}

		protected final function blink($stringText = Null) {
			try {
				try {
					/* verificamos si se creo la instancia */
					$this->verificarInstancia();
					/* verificamos si especifico la cadena */
					if ($stringText === Null)
						/* salimos con una excepcion */
						$this->newException('No se especifico la cadena a formatear');
					/* formateamos y retornamos la cadena formateada */
					return $this->getFormat($stringText, 'text-decoration:blink');
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$this->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$this->show($e->getMensaje());
			}
		}

		protected final function red($stringText = Null) {
			try {
				try {
					/* verificamos si se creo la instancia */
					$this->verificarInstancia();
					/* verificamos si especifico la cadena */
					if ($stringText === Null)
						/* salimos con una excepcion */
						$this->newException('No se especifico la cadena a formatear');
					/* formateamos y retornamos la cadena formateada */
					return $this->getFormat($stringText, "color:#{$this->redColor}");
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$this->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$this->show($e->getMensaje());
			}
		}

		protected final function green($stringText = Null) {
			try {
				try {
					/* verificamos si se creo la instancia */
					$this->verificarInstancia();
					/* verificamos si especifico la cadena */
					if ($stringText === Null)
						/* salimos con una excepcion */
						$this->newException('No se especifico la cadena a formatear');
					/* formateamos y retornamos la cadena formateada */
					return $this->getFormat($stringText, "color:#{$this->greenColor}");
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$this->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$this->show($e->getMensaje());
			}
		}

		protected final function blue($stringText = Null) {
			try {
				try {
					/* verificamos si se creo la instancia */
					$this->verificarInstancia();
					/* verificamos si especifico la cadena */
					if ($stringText === Null)
						/* salimos con una excepcion */
						$this->newException('No se especifico la cadena a formatear');
					/* formateamos y retornamos la cadena formateada */
					return $this->getFormat($stringText, "color:#{$this->blueColor}");
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$this->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$this->show($e->getMensaje());
			}
		}

		protected final function yellow($stringText = Null) {
			try {
				try {
					/* verificamos si se creo la instancia */
					$this->verificarInstancia();
					/* verificamos si especifico la cadena */
					if ($stringText === Null)
						/* salimos con una excepcion */
						$this->newException('No se especifico la cadena a formatear');
					/* formateamos y retornamos la cadena formateada */
					return $this->getFormat($stringText, "color:#{$this->yellowColor}");
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$this->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$this->show($e->getMensaje());
			}
		}

		protected final function getTimeNow() {
			try {
				try {
					/* verificamos si se creo la instancia */
					$this->verificarInstancia();
					/* agregamos el tiempo transcurrido al tiempo actual */
					self::$timeNow = $this->getTime() - self::$timeStart;
					/* retornamos el tiempo con formato de 3 decimales y 6 digitos */
					return str_pad(number_format(self::$timeNow, 3, ',', '.'), 7, '0', STR_PAD_LEFT);
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$this->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$this->show($e->getMensaje());
			}
		}

		protected final function newException($stringMsg = False) {
			/* creamos una exepcion temporal para obtener el lugar de origen y agregarlo al error */
			$tempException = new MyException('error');
			/* asignamos el error con el lugar de origen (llamada al metodo) */
			$this->setError($stringMsg . $tempException->getFrom());
			/* enviamos una exepcion para mostrar el error */
			throw new MyException($this->getError(False, True));
		}

		protected final function convertToMyException($exception) {
			/* obtenemos el mensaje de error */
			$string = $exception->getMessage();
			/* obtenemos el fichero de origen */
			$file = basename($exception->getFile());
			/* verificamos si la cadena de error ya tiene el nombre del fichero */
			if (!strstr($string, $file))
				/* si no tiene agregamos el nombre del fichero y la linea de error */
				$string	.= ', executed in ' . $this->italic($file) . ':' . $exception->getLine();
			/* enviamos la nueva excepcion */
			$this->newException($string);
		}

		protected function verificarClase($className = 'MyException') {
			/* verificamos si existe */
			if (!class_exists($className)) {
				/* armamos el mensaje a mostrar */
				$mensajeError = 'Se necesita de la clase ' . $className . ' para utilizar la clase ' . ($this->getName() === False ? __CLASS__ : $this->getName());
				/* verificamos si existe la clase 'MyException' */
 				if (class_exists('MyException'))
					/* matamos el proceso con una excepcion */
 					$this->newException($mensajeError);
				/* si no existe matamos el proceso con un mensaje */
				die($mensajeError);
			}
		}

		protected function getDebugStatus() {
			/* retornamos el estado de la depuracion */
			return $this->debugStat;
		}

		private function verificarVersion($version) {
			/* verificamos si especifico una version */
			if ($version === Null)
				/* retornamos true */
				return True;
			/* verificamos si es la version correcta */
			if (!self::getVersion($version))
				/* salimos con una excepcion */
				$this->newException('La version de la clase ' . $this->italic(__CLASS__) . ' solicitada es mayor a la actual (' . self::getVersion() . ')');
		}

		private function enableDebug($enable = True) {
			/* habilitamos la salida */
			$this->debugStat = $enable;
		}

		private function enableHtmlDebug() {
			/* habilitamos el formateo HTML */
			$this->html = True;
			/* habilitamos la salida de mensajes */
			$this->enableDebug();
		}

		private function verificarInstancia() {
			/* verificamos si esta creado */
			if ($this->created === False && !isset($this->activeError)) {
				/* habilitamos la depuracion */
				$this->debugStat = True;
				/* creamos la bandera */
				$this->activeError = True;
				/* deshabilitamos el titulo */
				$this->saltoMsg = True;
				/* salimos con una excepcion */
				$this->newException('No se llamo al metodo constructor de la clase ' . __CLASS__);
			}
		}

		private function getFormat($text, $style) {
			/* retornamos la cadena con formato */
			return "|font style='$style;'|$text|/font|";
		}

		private function getName() {
			/* retornamos el nombre actual */
			return $this->name;
		}

		private function saveTime() {
			/* guardamos el tiempo de inicio */
			self::$timeStart = $this->getTime();
		}

		private function vaciarBuffer() {
			/* vaciamos el buffer de salida */
			flush();
		}

		private function sleepRand() {
			/* verificamos si esta habilitada la bandera de tiempo */
			if ($this->timeEnabled)
				/* esperamos un tiempo aleatorio */
				usleep(rand(1000, $this->timeStep));
		}

		private function armarMostrarCadena($break) {
			/* agregamos el titulo y tiempo a la cadena */
			$this->agregarTituloTiempo();
			/* formateamos la cadena con HTML */
			$this->formatearCadena($break);
			/* verificamos si esta habilitada la bandera de depuracion */
			if ($this->getDebugStatus() === True)
				/* mostramos la cadena de salida */
				echo (
					/* verificamos si esta habilitada la salida html */
					$this->html === True ?
					/* mostramos la cadena */
					$this->cadenaShow :
					/* si no esta habilitada, eliminamos el HTML */
					strip_tags($this->cadenaShow)
				);
		}

		private function agregarTituloTiempo() {
			/* almacenamos la cadena con el titulo y el tiempo actual */
			$this->cadenaShow = (
				/* verificamos si mostramos el nombre */
				$this->saltoMsg == False ?
				/* agregamos el tiempo y nombre de la clase */
				'[' . $this->getTimeNow() . ' ' . $this->getName() . '::debug] ' :
				/* no agregamos nada */
				''
			/* agregamos la cadena */
			) . $this->cleanHTML($this->cadenaShow);
		}

		private function formatearCadena($break) {
			/* formateamos la cadena dentro de la etiquera CODE */
			$this->cadenaShow = "<code>{$this->cadenaShow}</code>";
			/* agregamos el salto de linea a la cadena */
			$this->agregarSaltoLinea($break);
		}

		private function agregarSaltoLinea($break) {
			/* verificamos si esta habilitada la bandera de salto de linea */
			if ($break === True)
				/* agregamos el salto a la cadena */
				$this->cadenaShow .= "<br/>\n";
			/* si no, agregamos un espacio */
			else
				$this->cadenaShow .= ' ';
		}

		private function saveLog($stringText, $break, $showName = True) {
			try {
				try {
					/* verificamos si esta habilitado el log */
					if ($this->logFile !== Null) {
						/* almacenamos el mensaje en el fichero log */
						fwrite($this->logFile, (
							/* verificamos si mostramos la cadena con el nombre */
							$showName === True && $this->saltoMsg === False ?
							/* agregamos el tiempo y nombre de la clase */
							'[' . $this->getTimeNow() . ' ' . $this->getName() . '::log] ' :
							/* no agregamos nada */
							''
						/* agregamos el mensaje sin las etiquetas html */
						) . strip_tags($this->cleanHTML($stringText)) . (
							/* verificamos si agregamos un salto */
							$break === True ?
							/* agregamos el salto */
							"\n" :
							/* agregamos un espacio */
							' '
						));
					}
				} catch (Exception $e) {
					/* capturamos todos los errores y los transformamos en mi excepcion */
					$this->convertToMyException($e);
				}
			} catch (MyException $e) {
				/* si se produjo una excepcion la manejamos con el metodo 'show' */
				$this->show($e->getMensaje());
			}
		}

		private function crearLogFile($fileName) {
			/* mostramos un mensaje */
			$this->show('Habilitando log en el fichero ' . $this->italic($fileName) . '..', False);
			/* verificamos si el fichero esta bloqueado */
			if (file_exists('log/' . $fileName . '.lock'))
				/* salimos con una excepcion */
				$this->newException('El fichero log esta bloqueado');
			/* almacenamos el nombre del fichero lock */
			$this->logFileLock = 'log/' . $fileName . '.lock';
			/* habilitamos el fichero para almacenar el log */
			$this->logFile = fopen('log/' . $fileName, 'a+');
			/* iniciamos el fichero log */
			$this->saveLog("\n" . '----- ' . $this->getName() . '::log ' . date('Y-m-d H:i:s') . ' -----', True, False);
			/* habilitamos la bandera para que muestre el nombre */
			$this->saltoMsg = False;
			/* almacenamos el mensaje mostrado */
			$this->saveLog('Habilitando log en el fichero ' . $this->italic($fileName) . '..', False);
			/* creamos el fichero lock */
			fclose(fopen($this->logFileLock, 'w'));
			/* deshabilitamos la bandera */
			$this->saltoMsg = True;
			/* mostramos ok al mensaje */
			$this->showOK();
		}

		private function cleanHTML($stringText) {
			/* reemplazamos algunos simbolos especiales por su codigo */
			$stringText = str_replace(Array('<', '>'), Array('&lt;', '&gt;'), $stringText);
			/* retornamos la cadena formateada */
			return str_replace(Array('|font', '|/font|', '\'|'), Array('<font', '</font>', '\'>'), $stringText);
		}
	}
?>